home *** CD-ROM | disk | FTP | other *** search
/ InfoMagic Internet Tools 1993 July / Internet Tools.iso / RockRidge / mail / mm / ccmd / cmnum.c < prev    next >
Encoding:
C/C++ Source or Header  |  1990-12-18  |  9.4 KB  |  279 lines
  1. /*
  2.  Copyright (c) 1986, 1990 by The Trustees of Columbia University in
  3.  the City of New York.  Permission is granted to any individual or
  4.  institution to use, copy, or redistribute this software so long as it
  5.  is not sold for profit, provided this copyright notice is retained.
  6.  
  7.  Author: Andrew Lowry
  8. */
  9. /* cmnum
  10. **
  11. ** This module contains the standard break table and handlers for
  12. ** parsing integers.  Parsing succeeds if current input contains an
  13. ** integer in a given radix (up to 16), and the return value is the int
  14. ** value parsed.  Optional flags can specify that a sign may or may not
  15. ** prefix the integer, and whether a successful parse should result if
  16. ** the integer is terminated by anything other than punctuation (as in
  17. ** "12am" as opposed to "12 am").  If parse-only is specified in the
  18. ** FDB (flag NUM_PO), the syntax of the number is checked, but no attempt
  19. ** at binary conversion is made, so overflow errors cannot occur.  In this
  20. ** case, the return value is the (possibly signed) string representing
  21. ** the integer.  It is left in the atom buffer.
  22. **
  23. ** Full completion simply terminates current input with a space if
  24. ** there is a valid integer.  If the input is empty or consists only
  25. ** of a sign, full completion beeps.  Partial completion always beeps.
  26. ** The standard break table allows digits, and letters A-F (and a-f).
  27. ** Minus and plus signs are also allowed in first position.
  28. **/
  29.  
  30. #define    NUMERR            /* declare cmnum parse errors here */
  31.  
  32. #include "ccmdlib.h"        /* get ccmd package symbols */
  33. #include "cmfncs.h"        /* and internal symbols */
  34.  
  35. /* Forward declaration of handler routines */
  36.  
  37. int numprs(), numhlp(), numcplt();
  38.  
  39. static brktab numbrk = {
  40.   {                    /* 1st char break array */
  41.     0xff, 0xff, 0xff, 0xff, 0xff, 0xeb, 0x00, 0x3f, /* allow - and + */
  42.     0x81, 0xff, 0xff, 0xff, 0x81, 0xff, 0xff, 0xff
  43.   },
  44.   {                    /* subsequent char break array */
  45.     0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x3f, /* disallow - and + */
  46.     0x81, 0xff, 0xff, 0xff, 0x81, 0xff, 0xff, 0xff
  47.   }
  48. };
  49.  
  50. ftspec ft_num = { numprs, numhlp, numcplt, 0, &numbrk }; /* handler structure */
  51.  
  52.  
  53.  
  54. /* numprs - Locate the digit string in the current input.  If there is
  55. ** none, error.  If NUM_PO is on in the FDB, the integer is parsed and
  56. ** returned as a string, with no attempt at binary conversion.  Otherwise
  57. ** convert to binary, keeping watch for overflow.
  58. **/
  59.  
  60. PASSEDSTATIC int
  61. numprs(text,textlen,fdbp,parselen,value)
  62. char *text;
  63. int textlen,*parselen;
  64. fdb *fdbp;
  65. pval *value;
  66. {
  67.   char *digits,*term,c;        /* for decomposing the input */
  68.   int sign;
  69.   int ndig;            /* number of digits */
  70.   int radix;            /* radix specified in the FDB */
  71.   int flags;            /* flags specified in the FDB */
  72.   unsigned int valhi,vallo;    /* high and low pieces of binary value */
  73.   int dig;            /* integer value of individual digit */
  74.   int intbits;            /* number of bits per integer */
  75.   int ret;            /* return code from aux routine */
  76.  
  77.   radix = (int) fdbp->_cmdat;    /* get the radix */
  78.   flags = fdbp->_cmffl;        /* and parse flags */
  79.                 /* parse the input */
  80.   ret = prsnum(text,textlen,flags,radix,&sign,&digits,&ndig,&term);
  81.   if (ret != CMxOK)
  82.     return(ret);        /* propagate problems */
  83.   if (term == NULL)
  84.     return(CMxINC);        /* unterminated field is incomplete */
  85.   if (digits == NULL)
  86.     return(NUMxNP);        /* terminated but no digits */
  87.   if (ndig < 1)            /* check ndig too - chris */
  88.     return (NUMxNP);        /* terminated but no digits */
  89.   if (flags & NUM_PO) {        /* parse only? */
  90.     value->_pvstr = cmcsb._cmabp; /* yup, string value in atom buffer */
  91.     *parselen = term - text;    /* compute number of characters */
  92.     return(CMxOK);
  93.   }
  94.   valhi =  -1;            /* count bits */
  95.   for (intbits = 0; valhi != 0; intbits++)
  96.     valhi <<= 1;        /* shift out bits until zeros remain */
  97.  
  98.   valhi = vallo = 0;        /* start with zero, then add in digits */
  99.   while (ndig-- > 0) {        /* loop through all the digits */
  100.     vallo *= radix;        /* multiply both pieces by radix */
  101.     valhi *= radix;
  102.     dig = ((*digits++) & CC_CHR) - '0'; /* get value of next digit */
  103.     if (dig > 9)
  104.       dig -= ('A'-'0')-10;    /* adjust non-numeric digits */
  105.     if (dig > 15)
  106.       dig -= 'a'-'A';        /* further adjust lowercase */
  107.     vallo += dig;        /* add in the new digit */
  108.     valhi += vallo >> 4;    /* leave only 4 bits in low part */
  109.     vallo &= 0xf;
  110.     if ((valhi >> (intbits-4)) != 0)
  111.       return(NUMxOV);        /* overflow */
  112.   }                /* go do next digit */
  113.   if (flags & NUM_US)        /* unsigned integer? */
  114.     valhi = (valhi << 4) | vallo; /* shift all bits into high piece */
  115.   else if (sign == -1)        /* need to negate it? */
  116.     if ((valhi >> intbits-5) == 0) /* in range for positive? */
  117.       valhi = -((valhi << 4) | vallo); /* yup, make abs val and negate */
  118.     else if (((valhi << 5) == 0) && (vallo == 0))
  119.       valhi = 1 << (intbits-1);    /* no, handle special case -2^(intbits-1) */
  120.     else
  121.       return(NUMxOV);        /* overflow */
  122.   else                /* positive signed integer */
  123.     if ((valhi >> intbits-5) == 0) /* in range? */
  124.       valhi = (valhi << 4) | vallo; /* yup, put pieces together */
  125.     else
  126.       return(NUMxOV);        /* nope, overflow */
  127.  
  128.   value->_pvint = (int) valhi;    /* set value in place */
  129.   *parselen = term - text;    /* compute consumed region */
  130.   return(CMxOK);        /* and give a good parse */
  131. }
  132.  
  133.  
  134.  
  135. /* numcplt - Partial completion always comes up empty.  Full completion
  136. ** gets a space if there are any digits in the buffer.
  137. **/
  138.  
  139. PASSEDSTATIC int
  140. numcplt(text,textlen,fdbp,full,cplt,cpltlen)
  141. char *text,**cplt;
  142. int textlen,full,*cpltlen;
  143. fdb *fdbp;
  144. {
  145.   int radix,flags;        /* radix and flags for parse */
  146.   char *digits,*term;        /* decomposed input */
  147.   int sign,ndig;
  148.   int ret;            /* return code from aux routine */
  149.  
  150.   radix = (int) fdbp->_cmdat;    /* get radix and flags */
  151.   flags = fdbp->_cmffl;
  152.                 /* try to parse the data */
  153.   ret = prsnum(text,textlen,flags,radix,&sign,&digits,&ndig,&term);
  154.  
  155.   *cplt = NULL;            /* we never supply completion text */
  156.   if (!full || (ndig == 0))    /* partial or no digits yet? */
  157.     return(CMP_BEL);        /* then just beep */
  158.   else
  159.     return(CMP_SPC | CMP_GO);    /* full gets a space and wakeup */
  160. }
  161.  
  162.  
  163.  
  164. /* numhlp - Just give a message customized by the requested radix.
  165. **/
  166.  
  167. PASSEDSTATIC int
  168. numhlp(text,textlen,fdbp,cust,lines)
  169. char *text;
  170. int textlen,cust;
  171. fdb *fdbp;
  172. int lines;
  173. {
  174.   int radix;            /* requested radix and flags */
  175.   int flags;
  176.   int caseadj = 0;        /* used when lowercasing initials */
  177.   char raddigs[3];        /* space for decimal string for radix value */
  178.  
  179. /* macro to print upper or lowercase char depending on value of caseadj */
  180. #define caseout(x) cmxputc((char) (x)+caseadj)
  181.  
  182.   radix = (int) fdbp->_cmdat;    /* get flags and radix */
  183.   flags = fdbp->_cmffl;
  184.   
  185.   if (flags & NUM_US) {
  186.     cmxputs("Unsigned ");    /* indicate if signs not allowed */
  187.     caseadj = 'a'-'A';        /* set up for lowercase initials */
  188.   }
  189.   switch (radix) {
  190.     case 2: caseout('B'); cmxputs("inary integer"); break;
  191.     case 8: caseout('O'); cmxputs("ctal integer"); break;
  192.     case 10: caseout('D'); cmxputs("ecimal integer"); break;
  193.     case 16: caseout('H'); cmxputs("exadecimal integer"); break;
  194.     default: caseout('I'); cmxputs("nteger in base ");
  195.       if (radix >= 10)        /* output radix in decimal */
  196.     cmxputc('1');
  197.       cmxputc((char) (radix % 10) + '0');
  198.       break;
  199.   }
  200.   return(lines-1);
  201. }
  202.  
  203.  
  204.  
  205. /* prsnum - Auxiliary routine for parse and completion.
  206. ** 
  207. ** Purpose:
  208. **   Breaks the current input into three pieces - sign, digits, and
  209. **   terminator, and checks to make sure that restrictions called
  210. **   for in the parse data flags are observed.
  211. **
  212. ** Input arguments:
  213. **   text - Pointer to input text.
  214. **   textlen - Number of characters of input text.
  215. **   flags - Flags supplied in the FDB.
  216. **   radix - Radix specified in the FDB.
  217. **
  218. ** Output arguments:
  219. **   sign - 0 for no sign, 1 for +, -1 for -.
  220. **   digits - Points to beginning of digit string.
  221. **   ndig - Number of digits in digit string.
  222. **   term - Points to terminating character.
  223. **
  224. ** Returns: Standard error code.
  225. **/
  226.  
  227. static int
  228. prsnum(text,textlen,flags,radix,sign,digits,ndig,term)
  229. char *text, **digits, **term;
  230. int textlen, flags, radix, *sign, *ndig;
  231. {
  232.   int dig;            /* value of individual digit */
  233.   char c;
  234.  
  235.   if ((radix < 2) || (radix > 16)) /* check for bad radix */
  236.     return(NUMxRAD);
  237.  
  238.   *ndig = 0;            /* no digits scanned yet */
  239.   *sign = 0;            /* assume no sign */
  240.   *digits = text;        /* so digits start right away */
  241.   *term = NULL;            /* and no terminator given */
  242.  
  243.   if (textlen == 0)
  244.     return(CMxOK);        /* no text - all assumptions true */
  245.  
  246.   c = *text & CC_CHR;        /* pick up first char */
  247.   if ((c == '+') || (c == '-')) { /* sign at front? */
  248.     if (flags & NUM_US)        /* yup, check unsigned flag */
  249.       return(NUMxSGN);        /* was not supposed to be there */
  250.     *sign = (c == '+') ? 1 : -1; /* set the sign value */
  251.     *digits = ++text;        /* move digit start */
  252.     textlen--;            /* and count the character*/
  253.   }
  254.  
  255.   while (textlen-- > 0) {
  256.     c = *text & CC_CHR;        /* get next digit */
  257.     if (isdigit(c))
  258.       dig = c - '0';        /* adjust numeric digits */
  259.     else if (isupper(c))
  260.       dig = (c - 'A') + 10;    /* adjust uppercase digits */
  261.     else if (islower(c))
  262.       dig = (c - 'a') + 10;    /* adjust lowercase digits */
  263.     else
  264.       dig = 16;            /* anything else invalid */
  265.     if (dig >= radix)        /* terminator found? */
  266.       if (!isalnum(c) || (flags & NUM_BNP)) { /* valid terminator? */
  267.     *term = text;        /* point at terminator */
  268.         return(CMxOK);        /* and return */
  269.       }
  270.       else
  271.     return(NUMxNP);        /* bad terminator */
  272.     else {
  273.       (*ndig)++;        /* else bump digit counter */
  274.       text++;            /* and move on */
  275.     }
  276.   }
  277.   return(CMxOK);
  278. }
  279.